home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 2.iso / dist / fw_glimpse.idb / usr / freeware / src / glimpse-3.0 / get_filename.c.z / get_filename.c
C/C++ Source or Header  |  1997-09-09  |  12KB  |  368 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include "glimpse.h"
  5. #include <fcntl.h>
  6. #define  CHAR unsigned char
  7.  
  8. /* ----------------------------------------------------------------------
  9. get_filenames()
  10. input: an index table, (an index vector, i-th entry is ON if
  11. i-th partition is to be searched.), the partition table in src_index_set[]
  12. and the list of all files in "NAME_LIST".
  13. output: the list of filenames to be searched.
  14. ------------------------------------------------------------------------- */
  15.  
  16. #if    BG_DEBUG
  17. extern FILE *debug;
  18. #endif    /*BG_DEBUG*/
  19.  
  20. extern int  p_table[MAX_PARTITION];
  21. extern CHAR **GTextfiles;
  22. extern CHAR **GTextfilenames;
  23. extern int *GFileIndex;
  24. extern int GNumfiles;
  25. extern CHAR GProgname[];
  26. extern CHAR FileNamePat[];
  27. extern int  MATCHFILE;
  28. extern int  agrep_outpointer;
  29.  
  30. extern int mask_int[32];
  31. extern int OneFilePerBlock;
  32. extern char INDEX_DIR[MAX_LINE_LEN];
  33. extern    unsigned int    *multi_dest_index_set[MAXNUM_PAT];
  34. extern int file_num;    /* in index/io.c */
  35. int bigbuffer_size;
  36. char *bigbuffer = NULL;    /* constant buffer to read all filenames in NAME_LIST */
  37. char *outputbuffer = NULL;    /* keeps changing: used for -F search via memagrep */
  38. extern int REAL_PARTITION, REAL_INDEX_BUF, MAX_ALL_INDEX, FILEMASK_SIZE;
  39.  
  40. read_filenames()
  41. {
  42.     struct stat st;
  43.     unsigned char buffer[MAX_NAME_SIZE];
  44.     char *currptr;
  45.     int i;
  46.  
  47.     /* one time processing: assumes during one run of glimpse, the index remains constant! */
  48.     if (bigbuffer == NULL) {
  49.         FILE *fp = fopen(NAME_LIST, "r");
  50.  
  51.         if (fp == NULL) {
  52.             fprintf(stderr, "Can't open for reading: %s/%s\n", INDEX_DIR, NAME_LIST);
  53.             exit(2);
  54.         }
  55.         if (-1 == stat(NAME_LIST, &st)) {
  56.             fclose(fp);
  57.             fprintf(stderr, "Can't stat: %s/%s\n", INDEX_DIR, NAME_LIST);
  58.             exit(2);
  59.         }
  60.         fgets(buffer, MAX_NAME_SIZE, fp);
  61.         bigbuffer_size = st.st_size - strlen(buffer);
  62.         sscanf(buffer, "%d", &file_num);
  63.         if ((file_num < 0) || (file_num > MaxNum24bPartition)) {
  64.             fclose(fp);
  65.             fprintf(stderr, "Error in reading: %s/%s\n", INDEX_DIR, NAME_LIST);
  66.             exit(2);
  67.         }
  68.         initialize_data_structures(file_num);
  69.         for (i=0; i<MAXNUM_PAT; i++) {
  70.             multi_dest_index_set[i] = (unsigned int *)my_malloc(sizeof(int)*REAL_PARTITION);
  71.             memset(multi_dest_index_set[i], '\0', sizeof(int) * REAL_PARTITION);
  72.         }
  73.         bigbuffer = (char *)my_malloc(bigbuffer_size + MAX_PAT + 2);    /* The whole file + place to store -F's pattern */
  74.         if (bigbuffer != NULL) outputbuffer = (char *)my_malloc(FILES_PER_PARTITION(file_num)*MAX_NAME_SIZE);    /* Space for max# files per partition */
  75.         if (outputbuffer != NULL) GTextfiles = (CHAR **) my_malloc(sizeof(CHAR *) * file_num);
  76.         if (GTextfiles != NULL) GTextfilenames = (CHAR **) my_malloc(sizeof(CHAR *) * file_num);
  77.         if (GTextfilenames != NULL) GFileIndex = (int *)my_malloc(sizeof(int) * file_num);
  78.         if (bigbuffer == NULL || outputbuffer == NULL || GTextfiles == NULL || GTextfilenames == NULL || GFileIndex == NULL) {
  79.             fclose(fp);
  80.             fprintf(stderr, "%s: my_malloc failure in %s:%d!\n", GProgname, __FILE__, __LINE__);
  81.             exit(2);    /* No point freeing memory */
  82.         }
  83.         if (bigbuffer_size != fread(bigbuffer, 1, bigbuffer_size, fp)) {/* read in whole file in CONTIGUOUS memory */
  84.             fclose(fp);
  85.             fprintf(stderr, "Error in reading: %s/%s\n", INDEX_DIR, NAME_LIST);
  86.             exit(2);    /* No point freeing memory */
  87.         }
  88.         memset(bigbuffer+bigbuffer_size, '\n', MAX_PAT + 2);
  89.         for (i=0, currptr = bigbuffer; i<file_num && currptr < bigbuffer + bigbuffer_size; i++, currptr ++) {
  90.             GTextfilenames[i] = (unsigned char *)currptr;
  91.             while (*currptr != '\n') currptr ++;
  92.         }
  93.     }
  94.     return 0;
  95. }
  96.  
  97. get_filenames(index_vect, argc, argv, dummylen, dummypat, file_num)
  98. int  *index_vect;
  99. int argc; /* the arguments to agrep for -F */
  100. char *argv[];
  101. int dummylen;
  102. CHAR dummypat[];
  103. int file_num;
  104. {
  105.     int  i=0,j, ret;
  106.         int  start, end, k, prevk;
  107.     int filesseen;
  108.     char *beginptr, *endptr;
  109.  
  110. #if    BG_DEBUG
  111.     fprintf(debug, "get_filenames(): the following partitions are ON\n");
  112.     for(i=0; i<((OneFilePerBlock > 0) ? round(file_num, 8*sizeof(int)) : MAX_PARTITION); i++)
  113.         if(index_vect[i]) fprintf(debug, "i=%d,%x\n", i, index_vect[i]);
  114. #endif    /*BG_DEBUG*/
  115.  
  116.     GNumfiles = 0;
  117.     filesseen = 0;
  118.     endptr = beginptr = bigbuffer;
  119.  
  120.     if(MATCHFILE == OFF) {    /* just copy the filenames */
  121.         if (OneFilePerBlock) {
  122.         for (i=0; i<round(file_num, 8*sizeof(int)); i++) {
  123.             if (index_vect[i] == 0) continue;
  124.             for (j=0; j<8*sizeof(int); j++) {
  125.             if (!(index_vect[i] & mask_int[j])) continue;
  126.             start = i*8*sizeof(int) + j;
  127.             end = start + 1;
  128. #if    BG_DEBUG
  129.             fprintf(debug, "start=%d, end=%d\n", start, end);
  130. #endif    /*BG_DEBUG*/
  131.             /*
  132.              * skip over so many filenames and get the filenames to copy.
  133.              * NOTE: successive "start"s ALWAYS increase.
  134.              */
  135.  
  136.             while(filesseen < start) {
  137.                 while(*beginptr != '\n') beginptr ++;
  138.                 beginptr ++;    /* skip over '\n' */
  139.                 filesseen ++;
  140.             }
  141.  
  142.             endptr = beginptr;
  143.             while (filesseen < end) {
  144.                 while(*endptr != '\n') endptr ++;
  145.                 if (endptr == beginptr + 1) goto end_of_loop1;    /* null name of non-existent file */
  146.                 *endptr = '\0';
  147.                 /* return with all the names you COULD get */
  148.                 if ((GTextfiles[GNumfiles] = (CHAR *)strdup(beginptr)) == NULL) {
  149.                     *endptr = '\n';
  150.                     fprintf(stderr, "Out of memory at: %s:%d\n", __FILE__, __LINE__);
  151.                     return;
  152.                 }
  153.                 GFileIndex[GNumfiles] = i*8*sizeof(int) + j;
  154.                 *endptr = '\n';
  155.                 if (++GNumfiles >= file_num) goto end_files;
  156.             end_of_loop1:
  157.                 beginptr = endptr = endptr + 1;    /* skip over '\n' */
  158.                 filesseen ++;
  159.             }
  160.             }
  161.         }
  162.         } /* one file per block */
  163.         else {
  164.         /* Just the outer for-loop and initial begin/end values are different: rest is same */
  165.         for (i=0; i<MAX_PARTITION; i++) {
  166.             if(index_vect[i] > 0) {
  167.             start = p_table[i];
  168.             end = p_table[i+1];
  169.             if (start >= end) continue;
  170. #if    BG_DEBUG
  171.             fprintf(debug, "start=%d, end=%d\n", start, end);
  172. #endif    /*BG_DEBUG*/
  173.             /*
  174.              * skip over so many filenames and get the filenames to copy.
  175.              * NOTE: successive "start"s ALWAYS increase.
  176.              */
  177.  
  178.             while(filesseen < start) {
  179.                 while(*beginptr != '\n') beginptr ++;
  180.                 beginptr ++;    /* skip over '\n' */
  181.                 filesseen ++;
  182.             }
  183.  
  184.             endptr = beginptr;
  185.             while (filesseen < end) {
  186.                 while(*endptr != '\n') endptr ++;
  187.                 if (endptr == beginptr + 1) goto end_of_loop2;    /* null name of non-existent file */
  188.                 *endptr = '\0';
  189.                 /* return with all the names you COULD get */
  190.                 if ((GTextfiles[GNumfiles] = (CHAR *)strdup(beginptr)) == NULL) {
  191.                     *endptr = '\n';
  192.                     fprintf(stderr, "Out of memory at: %s:%d\n", __FILE__, __LINE__);
  193.                     return;
  194.                 }
  195.                 GFileIndex[GNumfiles] = filesseen;
  196.                 *endptr = '\n';
  197.                 if (++GNumfiles >= file_num) goto end_files;
  198.             end_of_loop2:
  199.                 beginptr = endptr = endptr + 1;    /* skip over '\n' */
  200.                 filesseen ++;
  201.             }
  202.             }
  203.         }
  204.         }
  205.     }
  206.     else {    /* search and copy matched filenames */
  207.         extern int REGEX, FASTREGEX;    /* agrep global which tells us whether the pattern is a regular expression or not */
  208.         int myREGEX, myFASTREGEX;
  209.         if ((dummylen = memagrep_init(argc, argv, MAX_PAT, dummypat)) <= 0) goto end_files;
  210.         ret = memagrep_search(dummylen, dummypat, dummylen*2, beginptr, FILES_PER_PARTITION(file_num)*MAX_NAME_SIZE, outputbuffer);
  211.         myREGEX = REGEX; myFASTREGEX = FASTREGEX;
  212.  
  213.         if (OneFilePerBlock) {
  214.         for (i=0; i<round(file_num, 8*sizeof(int)); i++) {
  215.             if (index_vect[i] == 0) continue;
  216.             for (j=0; j<8*sizeof(int); j++) {
  217.             if (!(index_vect[i] & mask_int[j])) continue;
  218.             start = i*8*sizeof(int) + j;
  219.             end = start + 1;
  220. #if    BG_DEBUG
  221.             fprintf(debug, "start=%d, end=%d\n", start, end);
  222. #endif    /*BG_DEBUG*/
  223.             /*
  224.              * skip over so many filenames and get the region to search =
  225.              * beginptr to endptr: NOTE: successive "start"s ALWAYS increase.
  226.              */
  227.  
  228.             while(filesseen < start) {
  229.                 while(*beginptr != '\n') beginptr ++;
  230.                 beginptr ++;    /* skip over '\n' */
  231.                 filesseen ++;
  232.             }
  233.             beginptr --;    /* I need '\n' for memory search */
  234.  
  235.             endptr = beginptr+1;
  236.             while (filesseen < end) {
  237.                 while(*endptr != '\n') endptr ++;
  238.                 endptr ++;    /* skip over '\n' */
  239.                 filesseen ++;
  240.             }
  241.             endptr --;    /* I need '\n' for memory search */
  242.             if (endptr == beginptr + 1) goto end_of_loop3;    /* null name of non-existent file */
  243.  
  244. #if    BG_DEBUG
  245.             *endptr = '\0';
  246.             fprintf(debug, "From %d searching:\n%s\n", filesseen, beginptr+1);
  247.             *endptr = '\n';
  248. #endif    /*BG_DEBUG*/
  249.  
  250.             /* if file in the partition matches then copy it */
  251.             if (myREGEX || myFASTREGEX) ret = memagrep_search(dummylen, dummypat, endptr-beginptr + 1, beginptr, FILES_PER_PARTITION(file_num)*MAX_NAME_SIZE, outputbuffer);
  252.             else ret = memagrep_search(dummylen, dummypat, endptr-beginptr/* + 1*/, beginptr+1, FILES_PER_PARTITION(file_num)*MAX_NAME_SIZE, outputbuffer);
  253.             if (ret > 0) {
  254. #if    BG_DEBUG
  255.                 {
  256.                 char c = outputbuffer[agrep_outpointer + 1];
  257.                 outputbuffer[agrep_outpointer + 1] = '\0';
  258.                 fprintf(debug, "OUTPUTBUFFER=%s\n", outputbuffer);
  259.                 outputbuffer[agrep_outpointer + 1] = c;
  260.                 }
  261. #endif    /*BG_DEBUG*/
  262.                 k = prevk = 0;
  263.                 while(k+1<agrep_outpointer) {    /* name of a file cannot have '\n' in it */
  264.                 k++;
  265.                 if (outputbuffer[k] == '\n') {
  266.                     outputbuffer[k] = '\0';
  267.                     /* return with all the names you COULD get */
  268.                     if ((GTextfiles[GNumfiles] = (CHAR *)strdup(outputbuffer+prevk)) == NULL) {
  269.                         outputbuffer[k] = '\n';
  270.                         fprintf(stderr, "Out of memory at: %s:%d\n", __FILE__, __LINE__);
  271.                         return;
  272.                     }
  273.                     outputbuffer[k] = '\n';
  274.                     GFileIndex[GNumfiles] = i*8*sizeof(int)+j;
  275.                     if (++GNumfiles >= file_num) goto end_files;
  276.                     k = prevk = k+1;
  277.                 }
  278.                 }
  279.             }
  280.             else {
  281.                 index_vect[i] &= ~mask_int[j];    /* remove it from the list: used if ByteLevelIndex */
  282.             }
  283.  
  284.             end_of_loop3:
  285.             beginptr = endptr = endptr + 1;
  286.             }
  287.         }
  288.         } /* one file per block */
  289.         else {
  290.         /* Just the outer for-loop and initial begin/end values are different: rest is same */
  291.         for (i=0; i<MAX_PARTITION; i++) {
  292.             if(index_vect[i] > 0) {
  293.             start = p_table[i];
  294.             end = p_table[i+1];
  295.             if (start >= end) continue;
  296. #if    BG_DEBUG
  297.             fprintf(debug, "start=%d, end=%d\n", start, end);
  298. #endif    /*BG_DEBUG*/
  299.             /*
  300.              * skip over so many filenames and get the region to search =
  301.              * beginptr to endptr: NOTE: successive "start"s ALWAYS increase.
  302.              */
  303.  
  304.             while(filesseen < start) {
  305.                 while(*beginptr != '\n') beginptr ++;
  306.                 beginptr ++;    /* skip over '\n' */
  307.                 filesseen ++;
  308.             }
  309.             beginptr --;    /* I need '\n' for memory search */
  310.  
  311.             endptr = beginptr+1;
  312.             while (filesseen < end) {
  313.                 while(*endptr != '\n') endptr ++;
  314.                 endptr ++;    /* skip over '\n' */
  315.                 filesseen ++;
  316.             }
  317.             endptr --;    /* I need '\n' for memory search */
  318.             if (endptr == beginptr + 1) goto end_of_loop4;    /* null name of non-existent file */
  319.  
  320. #if    BG_DEBUG
  321.             *endptr = '\0';
  322.             fprintf(debug, "From %d searching:\n%s\n", filesseen, beginptr+1);
  323.             *endptr = '\n';
  324. #endif    /*BG_DEBUG*/
  325.  
  326.             /* if file in the partition matches then copy it */
  327.             if (myREGEX || myFASTREGEX) ret = memagrep_search(dummylen, dummypat, endptr-beginptr + 1, beginptr, FILES_PER_PARTITION(file_num)*MAX_NAME_SIZE, outputbuffer);
  328.             else ret = memagrep_search(dummylen, dummypat, endptr-beginptr/* + 1*/, beginptr+1, FILES_PER_PARTITION(file_num)*MAX_NAME_SIZE, outputbuffer);
  329.             if (ret > 0) {
  330.                 k = prevk = 0;
  331.                 while(k+1<agrep_outpointer) {    /* name of a file cannot have '\n' in it */
  332.                 k++;
  333.                 if (outputbuffer[k] == '\n') {
  334.                     outputbuffer[k] = '\0';
  335.                     /* return with all the names you COULD get */
  336.                     if ((GTextfiles[GNumfiles] = (CHAR *)strdup(outputbuffer+prevk)) == NULL) {
  337.                         outputbuffer[k] = '\n';
  338.                         fprintf(stderr, "Out of memory at: %s:%d\n", __FILE__, __LINE__);
  339.                         return;
  340.                     }
  341.                     outputbuffer[k] = '\n';
  342.                     GFileIndex[GNumfiles] = filesseen - 1;    /* not sure here which one but this is never used so ok to fill junk */
  343.                     if (++GNumfiles >= file_num) goto end_files;
  344.                     k = prevk = k+1;
  345.                 }
  346.                 }
  347.             }
  348.             else {
  349.                 index_vect[i] = 0;    /* mask it off */
  350.             }
  351.  
  352.             end_of_loop4:
  353.             beginptr = endptr = endptr + 1;
  354.             }
  355.         }
  356.         }
  357.     }
  358.  
  359. end_files:
  360. #if    BG_DEBUG
  361.     fprintf(debug, "The following %d filenames are ON\n", GNumfiles);
  362.     for (i=0; i<GNumfiles; i++)
  363.         fprintf(debug, "\t%s\n", GTextfiles[i]);
  364. #endif    /*BG_DEBUG*/
  365.     return;
  366. }
  367.  
  368.